# -*- coding: utf-8 -*-

import bpy
import os
import shutil
from . import fr_kk_func

def kk_get_baker(material, max_size, output_dir):
    '''根据材质获取对应的 baker.
    返回的是一个 MmdKkBakeTextureBase 对象'''
    mat_type = fr_kk_func.kk_get_material_type(material.name)

    # target_types = ['COMMON']
    target_types = []
    if len(target_types) > 0 and mat_type not in target_types:
        return

    if mat_type == 'CLOTH':
        # return
        return MmdKkBakeCloth(material, max_size, output_dir)
    elif mat_type == 'COMMON':
        return MmdKkBakeCommon(material, max_size, output_dir)
    elif mat_type == 'SKIN':
        return MmdKkBakeSkin(material, max_size, output_dir)
    elif mat_type == 'TANG':
        return MmdKkBakeTang(material, max_size, output_dir)
    elif mat_type == 'HAIR':
        return MmdKkBakeHair(material, max_size, output_dir)
    else:
        return MmdKkBakeTextureBase(material, max_size, output_dir)

def kk_link_scalable_tex(tex_name: str, group_name: str, group_input: str, mat_nodes, compositing):
    '''tex_name 所对应的贴图允许一定范围的缩放和偏移.
    - 允许uv缩放(仅限>=1)的贴图.
    - 允许uv偏移(这里偏移 0~1 就已经对应了所有范围)
    注意, 映射类型必须是 TEXTURE, 默认是 Point
    '''
    mat_tex = mat_nodes.get(tex_name)
    nodes = compositing.nodes
    links = compositing.links
    comp_tex = nodes.get(tex_name)
    comp_group = nodes.get(group_name)
    mat_input = mat_tex.inputs['Vector'].links
    scale_group = 'KK_comp_uv_scale'
    scale_name = tex_name + '_scale'
    if len(mat_input) > 0 and mat_input[0].from_node.bl_idname == 'ShaderNodeMapping':
        mapping = mat_input[0].from_node
        if mapping.vector_type == 'TEXTURE':
            scale_x = mapping.inputs[3].default_value[0]
            scale_y = mapping.inputs[3].default_value[1]
            offset_x = mapping.inputs[1].default_value[0]
            offset_y = mapping.inputs[1].default_value[1]
            if (scale_x >= 1 and scale_y >= 1) or offset_x != 0 or offset_y != 0:
                # 符合条件, 可以在 合成 面板里实现 uv 缩放
                scale_node = nodes.get(scale_name)
                if not scale_node:
                    scale_node = nodes.new('CompositorNodeGroup')
                    scale_node.node_tree = bpy.data.node_groups[scale_group]
                    scale_node.name = scale_name
                    scale_node.location = (comp_tex.location[0] + 200, comp_tex.location[1])
                scale_node.inputs['ScaleX'].default_value = scale_x
                scale_node.inputs['ScaleY'].default_value = scale_y
                scale_node.inputs['OffsetX'].default_value = offset_x
                scale_node.inputs['OffsetY'].default_value = offset_y
                links.new(comp_tex.outputs['Image'], scale_node.inputs['Image'])
                links.new(scale_node.outputs['Image'], comp_group.inputs[group_input])
                return
    # 默认行为是用 贴图 节点直接连接 shader (无缩放)
    links.new(comp_tex.outputs['Image'], comp_group.inputs[group_input])

# 烘焙的基类, 本身不会烘焙贴图, 提供了一些公用方法
class MmdKkBakeTextureBase:
    def __init__(self, material, max_size: str, output_dir: str):
        '''max_size 是贴图最大尺寸(NO_LIMIT 表示不限制).'''
        self.nodes = material.node_tree.nodes
        self.material = material
        self.max_size = max_size
        self.output_dir = output_dir
        # 材质类型
        self.material_type = fr_kk_func.kk_get_material_type(material.name).lower()
        # 当前材质对应的合成节点组的名称
        self.comp_group_name = 'KK_comp_'+self.material_type
        # 当前材质对应的shader节点组的名称
        self.mat_group_name = 'KK_shader_'+self.material_type
        # 当前材质需要用到的贴图类型, 子类需要按需求设置
        self.texture_types = ['kk_main_tex', 'kk_color_mask', 'kk_detail_mask']
        # 所有贴图类型, 及其属性
        # pos 是贴图在合成面板中的位置
        self.texture_dict = {
            'kk_main_tex': {'pos': (-500, 850)},
            'kk_color_mask': {'pos': (-500, 1300)},
            'kk_detail_mask': {'pos': (-500, 1750)},
            'kk_hair_gloss': {'pos': (-1000, 850)},
            'kk_overlay1': {'pos': (-1000, 1750)},
            'kk_overlay2': {'pos': (-1000, 1300)},
            'kk_line_mask': {'pos': (-1300, 1750)},
        }
        # self.scene 和 self.compositing 是在 setup_scene 方法中配置的

    def bake_texture(self):
        '''执行贴图烘焙'''
        # 这个方法在必要的情况下需要
        # - 设置一个 (与材质名称相同的) scene 来合成某个材质的贴图
        # - 在 scene 的合成节点中设置好节点
        # - 烘焙(渲染) 贴图
        # - 然后在 材质中设置好烘焙后的贴图作为 mmd_base_tex 等
        self.bake_diffuse()

    def bake_diffuse(self):
        '''直接把 main_tex 作为 mmd 的颜色贴图.'''
        mat_nodes = self.nodes

        if mat_nodes.get('mmd_base_tex'):
            main_tex = mat_nodes.get('kk_main_tex')
            base_tex = mat_nodes.get('mmd_base_tex')
            if main_tex and main_tex.image:
                base_tex.image = main_tex.image
        elif mat_nodes.get('kk_main_tex'):
            main_tex = mat_nodes.get('kk_main_tex')
            if main_tex.image:
                mmd_base_tex = mat_nodes.new('ShaderNodeTexImage')
                mmd_base_tex.location = (-1200, 620)
                mmd_base_tex.image = main_tex.image
                mmd_base_tex.name = 'mmd_base_tex'
                mmd_base_tex.label = 'mmd_base_tex'

    def get_tex_node(self, comp_nodes, name, pos):
        """获取一个合成用的贴图节点(如果不存在就创建)."""
        nodes = comp_nodes
        if not nodes.get(name):
            tex = nodes.new('CompositorNodeImage')
            tex.name = name
            #tex.label = name
            tex.location = pos
        else:
            tex = nodes.get(name)
            tex.image = None
        return tex

    def _reset_comp_node(self, comp_tree, textures):
        '''重置合成面板中的节点, 并且断开连接, 设置 scene 的渲染尺寸(作为图片输出).
        textures 是需要初始化的 贴图类型的名称列表
        '''
        nodes = comp_tree.nodes
        links = comp_tree.links
        mat_name = self.material.name
        comp_name = self.comp_group_name

        comp_group = nodes.get(comp_name)
        if not comp_group:
            comp_group = nodes.new('CompositorNodeGroup')
            comp_group.node_tree = bpy.data.node_groups[comp_name]
            comp_group.name = comp_name
            comp_group.location = (0, 1300)

        texture_nodes = {}
        for tex in textures:
            pos = self.texture_dict[tex]['pos']
            texture_nodes[tex] = self.get_tex_node(nodes, tex, pos)
        if not nodes.get('kk_output'):
            output = nodes.new('CompositorNodeOutputFile')
            output.name = 'kk_output'
            output.location = (400, 1300)
        else:
            output = nodes.get('kk_output')
        output.base_path = self.output_dir
        # 这个 path 是文件名前缀, 实际文件名是 base_path +'/'+ path + '0001.png'
        output.file_slots[0].path = mat_name
        # 不适用 node 的图片格式, 则默认的输出格式是 png 文件
        output.file_slots[0].use_node_format = False

        # 如果当前 scene 中不存在摄像机, 则新建一个
        if not bpy.context.scene.camera:
            bpy.ops.object.camera_add()

        # 断开 group 上的所有链接
        fr_kk_func.disconnect_node_link(comp_group, links)
        # fr_kk_func.disconnect_node_link(output, links)
        return [output, texture_nodes, comp_group]

    def _setup_output_texture_size(self):
        '''根据配置和贴图尺寸决定输出的贴图尺寸.'''
        mat_nodes = self.nodes

        if self.max_size is 'NO_LIMIT':
            max_size = 8192
        else:
            max_size = int(self.max_size)
        # 默认最小尺寸
        output_size = 32
        output_xy = [32, 32]

        # 根据当前材质使用的贴图类型来获取其中最大贴图尺寸, 并设置为当前场景的尺寸(等于输出贴图的尺寸)
        types = self.texture_types
        for tex_name in types:
            tex_node = mat_nodes.get(tex_name)
            if tex_node and tex_node.image:
                image = tex_node.image
                if image.size[0] > output_size:
                    output_size = image.size[0]
                    output_xy = image.size
                if image.size[1] > output_size:
                    output_size = image.size[1]
                    output_xy = image.size

        if output_xy[0] > max_size or output_xy[1] > max_size:
            if output_xy[0] >= output_xy[1]:
                divide = output_xy[0] / max_size
            else:
                divide = output_xy[1] / max_size
            output_xy = [ int(s / divide) for s in output_xy]
        self.scene.render.resolution_x = output_xy[0]
        self.scene.render.resolution_y = output_xy[1]

    def setup_scene(self):
        '''配置 scene, 配置最大贴图尺寸, 重置节点.'''
        scene_name = 'bake_' + self.material.name
        if not scene_name in bpy.data.scenes:
            bpy.ops.scene.new()
            # 这里要使场景名称在 scene 之前(字幕顺序排序...), 才能保证新建的场景是最后一个
            scene = bpy.data.scenes[len(bpy.data.scenes)-1]
            scene.name = scene_name
        else:
            scene = bpy.data.scenes[scene_name]
        self.scene = scene
        # bpy.context.area.ui_type = 'CompositorNodeTree'
        # 切换当前显示的 scene
        bpy.context.window.scene = scene
        bpy.context.window.workspace = bpy.data.workspaces['Compositing']
        scene.use_nodes = True
        scene.view_settings.view_transform = 'Standard'
        self.compositing = scene.node_tree
        # 设置输出贴图尺寸
        self._setup_output_texture_size()
        # 重置(并配置)合成节点
        return self._reset_comp_node(self.compositing, self.texture_types)

    def render_texture(self):
        mat_nodes = self.material.node_tree.nodes
        mat_name = self.material.name
        bpy.ops.render.render(use_viewport=True)
        # 渲染之后还需要改贴图文件名
        file_dir = os.path.dirname(bpy.context.blend_data.filepath) + self.output_dir + '/'
        render_path = file_dir + mat_name + '0001.png'
        filename = mat_name + '_color.png'
        # 颜色贴图名称
        filepath = file_dir + filename

        if os.path.isfile(render_path):
            shutil.move(render_path, filepath)
        else:
            return
        # 导出贴图之后, 在材质节点里导入贴图, 并设置为 mmd_base_tex
        # 删除可能存在的 'mmd_base_tex' 节点, 来避免可能出现的问题(比如复制的材质, 多个材质共用一个贴图是不正确的)
        base_tex = mat_nodes.get('mmd_base_tex')
        if base_tex:
            mat_nodes.remove(base_tex)

        image = bpy.data.images.load(filepath, check_existing=True)
        if image:
            mmd_base_tex = mat_nodes.new('ShaderNodeTexImage')
            mmd_base_tex.location = (-1200, 620)
            mmd_base_tex.image = image
            mmd_base_tex.name = 'mmd_base_tex'
            mmd_base_tex.label = 'mmd_base_tex'

class MmdKkBakeCloth(MmdKkBakeTextureBase):
    def bake_diffuse(self):
        '''烘焙 cloth 类型的贴图'''
        # 重置(并配置)合成节点
        # 这里的 textures 里是 合成 中的贴图节点
        [output, textures, cloth_group] = self.setup_scene()
        mat_nodes = self.material.node_tree.nodes
        mat_name = self.material.name
        mat_shader = mat_nodes.get(self.mat_group_name)
        comp_links = self.compositing.links
        comp_nodes = self.compositing.nodes

        main_tex = textures['kk_main_tex']
        detail_mask = textures['kk_detail_mask']
        color_mask = textures['kk_color_mask']

        # 只有贴图存在时, 才使用之
        if mat_nodes.get('kk_main_tex'):
            main_tex.image = mat_nodes.get('kk_main_tex').image
            if main_tex.image:
                comp_links.new(main_tex.outputs['Image'], cloth_group.inputs['MainTex'])
        else:
            # 如果没有贴图节点, 直接设置颜色
            cloth_group.inputs['MainTex'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'MainTex')
        if mat_nodes.get('kk_detail_mask'):
            detail_mask.image = mat_nodes.get('kk_detail_mask').image
            if detail_mask.image:
                comp_links.new(detail_mask.outputs['Image'], cloth_group.inputs['DetailMask'])
        else:
            cloth_group.inputs['DetailMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailMask')
        if mat_nodes.get('kk_color_mask'):
            color_mask.image = mat_nodes.get('kk_color_mask').image
            if color_mask.image:
                comp_links.new(color_mask.outputs['Image'], cloth_group.inputs['ColorMask'])
        else:
            cloth_group.inputs['ColorMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'ColorMask')
        cloth_group.inputs['Color1'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color1')
        cloth_group.inputs['Color2'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color2')
        cloth_group.inputs['Color3'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color3')
        cloth_group.inputs['DetailFac'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailFac')
        # 这里 output 的 name 可能不好用
        comp_links.new(cloth_group.outputs['Image'], output.inputs[0])

        self.render_texture()

class MmdKkBakeHair(MmdKkBakeTextureBase):
    def bake_diffuse(self):
        '''烘焙 hair 类型的贴图.'''
        self.texture_types = ['kk_main_tex', 'kk_color_mask', 'kk_detail_mask', 'kk_hair_gloss']
        # 重置(并配置)合成节点
        [output, textures, comp_group] = self.setup_scene()
        mat_nodes = self.material.node_tree.nodes
        mat_name = self.material.name
        mat_shader = mat_nodes.get(self.mat_group_name)
        comp_links = self.compositing.links
        comp_nodes = self.compositing.nodes

        main_tex = textures['kk_main_tex']
        detail_mask = textures['kk_detail_mask']
        color_mask = textures['kk_color_mask']
        hair_gloss = textures['kk_hair_gloss']

        # 只有贴图存在时, 才使用之
        if mat_nodes.get('kk_main_tex'):
            main_tex.image = mat_nodes.get('kk_main_tex').image
            if main_tex.image:
                comp_links.new(main_tex.outputs['Image'], comp_group.inputs['MainTex'])
        else:
            # 如果没有贴图节点, 直接设置颜色
            comp_group.inputs['MainTex'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'MainTex')
        if mat_nodes.get('kk_detail_mask'):
            detail_mask.image = mat_nodes.get('kk_detail_mask').image
            if detail_mask.image:
                comp_links.new(detail_mask.outputs['Image'], comp_group.inputs['DetailMask'])
        else:
            comp_group.inputs['DetailMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailMask')
        if mat_nodes.get('kk_color_mask'):
            color_mask.image = mat_nodes.get('kk_color_mask').image
            if color_mask.image:
                comp_links.new(color_mask.outputs['Image'], comp_group.inputs['ColorMask'])
        else:
            comp_group.inputs['ColorMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'ColorMask')
        # hair gloss 贴图(允许一定程度的uv变换)
        if mat_nodes.get('kk_hair_gloss'):
            hair_gloss.image = mat_nodes.get('kk_hair_gloss').image
            if hair_gloss.image:
                kk_link_scalable_tex('kk_hair_gloss', self.comp_group_name, 'HairGloss', mat_nodes, self.compositing)
        else:
            comp_group.inputs['HairGloss'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'HairGloss')

        comp_group.inputs['Color1'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color1')
        comp_group.inputs['Color2'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color2')
        comp_group.inputs['Color3'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color3')
        comp_group.inputs['DetailColor'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailColor')
        # 这里 output 的 name 可能不好用
        comp_links.new(comp_group.outputs['Image'], output.inputs[0])

        self.render_texture()

class MmdKkBakeTang(MmdKkBakeTextureBase):
    def bake_diffuse(self):
        '''烘焙漫射贴图.'''
        self.texture_types = ['kk_detail_mask']
        # 重置(并配置)合成节点
        [output, textures, comp_group] = self.setup_scene()
        mat_nodes = self.material.node_tree.nodes
        mat_shader = mat_nodes.get(self.mat_group_name)
        comp_links = self.compositing.links
        comp_nodes = self.compositing.nodes

        detail_mask = textures['kk_detail_mask']

        # 只有贴图存在时, 才使用之
        if mat_nodes.get('kk_detail_mask'):
            detail_mask.image = mat_nodes.get('kk_detail_mask').image
            # print(mat_nodes.get('kk_detail_mask').image.name)
            if detail_mask.image:
                # detail_mask.image.colorspace_settings.name = 'Non-Color'
                comp_links.new(detail_mask.outputs['Image'], comp_group.inputs['DetailMask'])
        else:
            comp_group.inputs['DetailMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailMask')
        comp_group.inputs['Color1'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color1')
        comp_group.inputs['Color2'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color2')
        # 这里 output 的 name 可能不好用
        comp_links.new(comp_group.outputs['Image'], output.inputs[0])

        self.render_texture()

class MmdKkBakeCommon(MmdKkBakeTextureBase):
    def bake_diffuse(self):
        '''烘焙漫射贴图.'''
        self.texture_types = ['kk_main_tex', 'kk_color_mask', 'kk_detail_mask', 'kk_overlay1', 'kk_overlay2']
        # 重置(并配置)合成节点
        [output, textures, comp_group] = self.setup_scene()
        mat_nodes = self.material.node_tree.nodes
        mat_shader = mat_nodes.get(self.mat_group_name)
        comp_links = self.compositing.links
        comp_nodes = self.compositing.nodes

        main_tex = textures['kk_main_tex']
        detail_mask = textures['kk_detail_mask']
        color_mask = textures['kk_color_mask']
        overlay1 = textures['kk_overlay1']
        overlay2 = textures['kk_overlay2']

        # 只有贴图存在时, 才使用之
        if mat_nodes.get('kk_main_tex'):
            main_tex.image = mat_nodes.get('kk_main_tex').image
            if main_tex.image:
                comp_links.new(main_tex.outputs['Image'], comp_group.inputs['MainTex'])
        else:
            # 如果没有贴图节点, 直接设置颜色
            comp_group.inputs['MainTex'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'MainTex')
        if mat_nodes.get('kk_detail_mask'):
            detail_mask.image = mat_nodes.get('kk_detail_mask').image
            if detail_mask.image:
                comp_links.new(detail_mask.outputs['Image'], comp_group.inputs['DetailMask'])
        else:
            comp_group.inputs['DetailMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailMask')
        if mat_nodes.get('kk_color_mask'):
            color_mask.image = mat_nodes.get('kk_color_mask').image
            if color_mask.image:
                comp_links.new(color_mask.outputs['Image'], comp_group.inputs['ColorMask'])
        else:
            comp_group.inputs['ColorMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'ColorMask')
        # overlay1 (允许一定程度的 uv 变换)
        if mat_nodes.get('kk_overlay1'):
            overlay1.image = mat_nodes.get('kk_overlay1').image
            if overlay1.image:
                kk_link_scalable_tex('kk_overlay1', self.comp_group_name, 'Overlay1', mat_nodes, self.compositing)
        else:
            comp_group.inputs['Overlay1'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Overlay1')
        # overlay2 (允许一定程度的 uv 变换)
        if mat_nodes.get('kk_overlay2'):
            overlay1.image = mat_nodes.get('kk_overlay2').image
            if overlay1.image:
                kk_link_scalable_tex('kk_overlay2', self.comp_group_name, 'Overlay2', mat_nodes, self.compositing)
        else:
            comp_group.inputs['Overlay2'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Overlay2')

        comp_group.inputs['Color1'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color1')
        comp_group.inputs['Color2'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color2')
        comp_group.inputs['Color3'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color3')
        comp_group.inputs['DetailColor'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailColor')
        # 这里 output 的 name 可能不好用
        comp_links.new(comp_group.outputs['Image'], output.inputs[0])

        self.render_texture()

class MmdKkBakeCommon(MmdKkBakeTextureBase):
    def bake_diffuse(self):
        '''烘焙漫射贴图.'''
        self.texture_types = ['kk_main_tex', 'kk_color_mask', 'kk_detail_mask', 'kk_overlay1', 'kk_overlay2', 'kk_line_mask']
        # 重置(并配置)合成节点
        [output, textures, comp_group] = self.setup_scene()
        mat_nodes = self.material.node_tree.nodes
        mat_shader = mat_nodes.get(self.mat_group_name)
        comp_links = self.compositing.links
        comp_nodes = self.compositing.nodes

        main_tex = textures['kk_main_tex']
        detail_mask = textures['kk_detail_mask']
        color_mask = textures['kk_color_mask']
        overlay1 = textures['kk_overlay1']
        overlay2 = textures['kk_overlay2']
        line_mask = textures['kk_line_mask']

        # 只有贴图存在时, 才使用之
        if mat_nodes.get('kk_main_tex'):
            main_tex.image = mat_nodes.get('kk_main_tex').image
            if main_tex.image:
                comp_links.new(main_tex.outputs['Image'], comp_group.inputs['MainTex'])
        else:
            # 如果没有贴图节点, 直接设置颜色
            comp_group.inputs['MainTex'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'MainTex')
        # DetailMask, 一般用于增加细节, 不同材质的合成原理不一样
        if mat_nodes.get('kk_detail_mask'):
            detail_mask.image = mat_nodes.get('kk_detail_mask').image
            if detail_mask.image:
                comp_links.new(detail_mask.outputs['Image'], comp_group.inputs['DetailMask'])
        else:
            comp_group.inputs['DetailMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailMask')
        # ColorMask, 用来指定部分颜色的 Mask
        if mat_nodes.get('kk_color_mask'):
            color_mask.image = mat_nodes.get('kk_color_mask').image
            if color_mask.image:
                comp_links.new(color_mask.outputs['Image'], comp_group.inputs['ColorMask'])
        else:
            comp_group.inputs['ColorMask'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'ColorMask')
        # overlay1 (允许一定程度的 uv 变换)
        if mat_nodes.get('kk_overlay1'):
            overlay1.image = mat_nodes.get('kk_overlay1').image
            if overlay1.image:
                kk_link_scalable_tex('kk_overlay1', self.comp_group_name, 'Overlay1', mat_nodes, self.compositing)
        else:
            comp_group.inputs['Overlay1'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Overlay1')
        # overlay2 (允许一定程度的 uv 变换)
        if mat_nodes.get('kk_overlay2'):
            overlay2.image = mat_nodes.get('kk_overlay2').image
            if overlay2.image:
                kk_link_scalable_tex('kk_overlay2', self.comp_group_name, 'Overlay2', mat_nodes, self.compositing)
        else:
            comp_group.inputs['Overlay2'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Overlay2')
        # LineMask, 目前只有皮肤用到了
        if mat_nodes.get('kk_line_mask'):
            line_mask.image = mat_nodes.get('kk_line_mask').image
            if line_mask.image:
                kk_link_scalable_tex('kk_line_mask', self.comp_group_name, 'LineMask', mat_nodes, self.compositing)

        comp_group.inputs['Color1'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color1')
        comp_group.inputs['Color2'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color2')
        comp_group.inputs['Color3'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'Color3')
        comp_group.inputs['DetailColor'].default_value = fr_kk_func.get_input_color_value(mat_shader, 'DetailColor')
        # 这里 output 的 name 可能不好用
        comp_links.new(comp_group.outputs['Image'], output.inputs[0])

        self.render_texture()

class MmdKkBakeSkin(MmdKkBakeCommon):
    pass
